/*
数据结构 解题报告：
http://git.oschina.net/et0662/sznoi-Data_Structure
*/
#include<stdio.h>

typedef struct _ROOM
{
	int step;		// 从小老鼠a 到这里的最小步数
	int closed;		// 状态量, 封闭为1;
	int count;		// 最小步数的方法计数器
}Room;

typedef struct _NODE
{
	int x;						//bfs room的 x坐标
	int y;						//bfs room的 y坐标
	struct _NODE * next;
}Node, * ptrNode;

typedef struct _QUEUE
{
	ptrNode head;
	ptrNode tail;
}Queue, *ptrQueue;

//可以走4个方向，上下左右
int TX[4]={-1,0, 1, 0};
int TY[4]={ 0,1, 0,-1};

int num=0;
Room r[102][102];

//判断队列是否为空
int isEmpty(ptrQueue q)
{
	if(q->head->next)
		return 0;		// 0代表非空
	else
		return 1;		// 1代表空
}


//初始化队
ptrQueue initQueue()
{
	ptrQueue q=new Queue;
	ptrNode head=new Node;
	head->next=NULL;
	q->head=head;
	q->tail=NULL;
	return q;
}

//插入元素
void insert(ptrQueue q, ptrNode p)
{
	if(q->tail)
	{
		q->tail->next=p;
		q->tail=p;
	}
	else
	{
		q->head->next=p;
		q->tail=p;
	}
}

//出队
ptrNode outQueue(ptrQueue q)
{
	ptrNode p;
	if(q->head->next)
	{
		p=q->head->next;
		q->head->next=p->next;
		if(q->head->next==NULL)
			q->tail=NULL;
	}
	else
	{
		p=NULL;
	}
	return p;
}

//print test
void print(ptrQueue q)
{
	return;
	ptrNode p;
	p=q->head;
	while(p->next)
	{
		p=p->next;
		printf("(%d,%d)->",p->x,p->y);
	}
	printf("\n");
}

//dfs
void dfs(int k,int l,int n,int m,int p,int q, int x,int y)
{
	int i,j,sx,sy;
	if(k==l+1)
	{
		if((p==x)&&(q==y))
			num++;
	}
	else
	{
		sx=p;
		sy=q;

		for(j=0;j<4;j++)
		{
			sx=sx+TX[j];
			sy=sy+TY[j];
			if((1<=sx) && (sx<=n) && (1<=sy) && (sy<=m) )
			{
				if(!r[sx][sy].closed)
					dfs(k+1,l,n,m,sx,sy,x,y);
			}
			sx=sx-TX[j];
			sy=sy-TY[j];
		}

	}
}


int main(void)
{
	int m,n,k,i,j,a,b,p,q,x,y;
	int sx,sy;
	int minStep=0;
	ptrNode p0,p1;
	ptrQueue pq;
	scanf("%d%d%d",&n,&m,&k);

	/* 初始化*/
	for(i=0;i<=m+1;i++)
	{
		r[0][i].closed=1;
		r[n+1][i].closed=1;
	}
	for(i=0;i<=n+1;i++)
	{
		r[i][0].closed=1;
		r[i][m+1].closed=1;
	}
	for(i=1;i<=n;i++)
		for(j=1;j<=m;j++)
	{
		r[i][j].step=0;
		r[i][j].closed=0;
		r[i][j].count=0;
	}

	for(i=0;i<k;i++)
	{
		scanf("%d%d",&a,&b);
		r[a][b].closed=1;
	}

	scanf("%d%d",&p,&q);
	r[p][q].closed=1;
	scanf("%d%d",&x,&y);

	pq=initQueue();
	p0=new Node;

	p0->x=p;
	p0->y=q;
	p0->next=NULL;
	insert(pq,p0);

	while(!isEmpty(pq))
	{
		p0=outQueue(pq);
		//可以走4个方向，上下左右
		for(i=0;i<4;i++)
		{
			sx=p0->x+TX[i];
			sy=p0->y+TY[i];
			
			//sx,sy格子首先是 不 封闭的 !closed
			if(!r[sx][sy].closed)
			{
				if(r[sx][sy].step==0)
				{
					r[sx][sy].step=r[p0->x][p0->y].step+1;
					r[sx][sy].count=1;
					if((sx!=x) || (sy!=y))
					{
						if(minStep && (r[sx][sy].step>=minStep))
						{
							continue;
						}
						p1=new Node;
						p1->next=NULL;
						p1->x=sx;
						p1->y=sy;
						insert(pq,p1);
					}
					else
					{
						if(minStep)
						{
							if(minStep>r[sx][sy].step)
							{
								minStep=r[sx][sy].step;
							}
						}
					}
				}
				else if((r[p0->x][p0->y].step+1)<r[sx][sy].step)
				{
					r[sx][sy].step=r[sx][sy].count+r[p0->x][p0->y].count;
					r[sx][sy].count=1;
					if((sx!=x) || (sy!=y))
					{
						if(minStep && (r[sx][sy].step>=minStep))
						{
							continue;
						}
						p1=new Node;
						p1->next=NULL;
						p1->x=sx;
						p1->y=sy;
						insert(pq,p1);
					}
					else
					{
						if(minStep)
						{
							if(minStep>r[sx][sy].step)
							{
								minStep=r[sx][sy].step;
							}
						}
					}
				}
				else if((r[p0->x][p0->y].step+1)==r[sx][sy].step)
				{
					r[sx][sy].count=r[sx][sy].count+1;
				}else
				{
					;
				}
			}
		}
		delete(p0);
	}
	if(r[x][y].step)
	{
		dfs(1,r[x][y].step,n,m,p,q,x,y);
		printf("%d\n%d\n",r[x][y].step,num);
	}
	else
	{
		printf("No Solution!\n");
	}
	return 0;
}
